

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% 					Organisation du projet                         %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\noindent Le choix de la carte utilisée a du se faire parmi les cartes développées par la société allemande ZeitControl choisie par l'université à l'occasion de ce projet. Ces cartes, qui sont des cartes à système d'exploitation ouverts, ont été choisies parce qu'elles offrent une assez grande souplesse dans le contrôle de leur système d'exploitation.\\
Les cartes de la famille BasicCard ont une mémoire RAM comprise entre 256 et 2900 octets pour une mémoire EEPROM programmable par l'utilisateur allant de 2 à 60 kilooctets.\\

\noindent La mémoire EEPROM contient d'une part le code en Basic de l'utilisateur. Celui-ci sera compiler en P-code qui est une sorte de langage machine.la mémoire EEPROM sert aussi à stocker des données permanentes de l'utilisateur, ainsi que des variables Basic. Il est à noter qu'il existe également un système de fichiers dans les BasicCard dans lequel on peut stocker ces variables et ces données. Quant à elle, la mémoire RAM contient les données d'exécution la pile du P-code.\\
ZeitControl a développé dans la famille de cartes BasicCard des cartes dites "single-application", qui ne peuvent contenir qu'une seule application, et des cartes "multi-application" qui peuvent contenir jusqu'à 128 applications. Une carte multi-application pourrait être une carte bancaire implémentant monéo\texttrademark et l'application VISA\texttrademark.\\


\subsection{Caractéristiques d'un programme pour BasicCard}
Un programme en ZC-Basic est essentiellement une suite de définition de procédures écrites dans un langage d'assez haut niveau qui inclue également l'utilisation de commandes qui permettent d'accéder à des informations sur la carte et de mettre en œuvre des mécanismes de chiffrement. 


\subsubsection{Généralités}
De manière générale, un programme BasicCard - le programme implémenté dans la puce - est contenu dans un seul fichier source. Cependant celui-ci peut inclure d'autres fichiers. l'extension du fichier est .BAS. Il contient un ensemble de commandes avec les fichiers et les données associés. Dans le cas d'un programme de carte simulée l'extension du fichier sera .ZCC. \\
Un programme BasicCard est composé d'une partie code d'initialisation et d'une partie définition des procédures.\\

\subsubsection{La partie initialisation du code}
C'est une partie facultative. Elle correspond à la première partie du code et n'est pas incluse dans la définition d'une procédure. Cette partie du code sera exécutée pour une carte "single-application" à l'appel de la première commande par le terminal, alors que pour une carte "multi-applications" la partie initialisation d'une application sera exécutée lorsque cette application sera sélectionnée. Elle permet entre autre mettre en place des mécanismes de vérification.\\

\subsubsection{La partie définition des procédures}
Chaque procédure constitue une seule et même entité; elle est autonome. BasicCard permet d'implémenter trois types de procédures :
\begin{itemize}
	\item \textbf{Les sous-routines} qui peuvent être appelées par d'autres procédures.
	\item \textbf{Les fonctions} qui sont des sous-routines qui retournent une valeur.
	\item \textbf{Les commandes} qui permettent la communication entre la carte et le terminal.
\end{itemize}

\subsubsection{Les données permanentes}
Les données dont on veut conserver la valeur de manière permanente sont stockées dans la mémoire de type EEPROM qui est une mémoire programmable qui peut être effacée électriquement. On peut y stocker des nombres, des chaines ou des tableaux.

\subsection{Caractéristiques du programme pour terminal}
L'extension du programme du terminal est .ZCT. Il contient d'une part une procédure principale, d'autre part les définitions des procédures nécessaires au programme ainsi que la déclaration des commandes définies dans la BasicCard pour que le programme terminal puisse les appeler.

\subsubsection{La procédure principale et définitions des autres procédures}
La procédure principale (main procedure) commence à partir de la première déclaration qui n'est pas incluse dans la définition d'une procédure quelconque. La procédure principale peut se trouver entre deux définitions de procédures. Dans ce cas elle se termine au début de la définition de la procédure suivante. Si elle ne situe pas entre deux déclarations de procédure, alors elle se termine à la fin du fichier.

\subsubsection{Définitions de procédures}
Les procédures dans le programme du terminal sont en fait des fonctions ou des sous-routines. Chaque procédure est autonome. Les procédures imbriquées sont interdites.

\subsubsection{Déclarations des commandes}
Pour que le terminal puisse appeler une commande de la carte, il faut déclarer celle-ci. La déclaration s'effectue à l'aide de l'identifiant codé sur 2 octets comme ci-dessous :

\subsection{Le langage ZC-Basic}

\subsubsection{Généralités}
De manière assez classique un programme en ZC-basic consiste en des séquences de "\textit{token}". Quatre type de "\textit{token}" sont définis: les constantes, les identifiants, les mots réservés, et les symboles spéciaux.\\
Le langage ZC-basic met également en \oe{oe}uvre des directives pour le pré-processeur telles que l'inclusion de fichier, la définition de constantes, l'inclusion de librairie, la compilation conditionnelle.\\
Les types de données sont Byte, Integer, Long, Single (pour les flottants), String et String*n (pour les chaînes de caractères de \textbf{n} octets de long). Il est également possibles de déclarer ses propres types de données ainsi que des tableaux pour chacun des types de données.\\

3 types d'expressions sont définies dans le langage de ZC-Basic. Elles peuvent être classiquement des expressions numériques ou à bases de caractères. Mais il est également possible de créer des expressions avec un type défini par l'utilisateur. Dans ce cas seule une opération est possible: déterminer si deux expressions sont égales ou pas.\\
ZC-Basic propose également les structures de contrôle classiques telle que les boucles \textit{If-Then-Else} ,\textit{For},\textit{While}, \textit{Do-While} ou \textit{Select Case} (équivalent de \textit{switch case} en C. Il existe deux autres déclarations de conrôles \textit{GoTo} et \textit{GoSub} qui permettent sauter une partie de l'exécution de programme. Notons que \textit{GoTo} ne permet pas de sauter d'une procédure à une autre.

\subsubsection{Stockage des données}
Il y a quatre classes de stockage : Eeprom, Public, Static ou Private.\\
Une donnée de la classe Eeprom conserve sa valeur lorsque le système n'est plus alimentée. On stocke ainsi dans cette classe le programme compilé, les répertoires et les fichiers ainsi que toutes les variables permanentes. Toute les procédures peuvent accéder à la mémoire Eeprom.\\

Les classes Public et Static concernent la RAM. Public est utilisée pour des données vues globalement alors que Static sont vues uniquement par la procédure où elle a été définie. Dans le cadre d'une donnée déclarée Private dans une procédure celle-ci n'existera que le temps pendant lequel sera appelé cette procédure.
\pagebreak

\subsubsection{Définition, déclaration et appel des procédures}

\textbf{Définition d'une procédure}

\begin{enumerate}
\item Les sous-routines\\
C'est la procédure la plus simple. Elle se déclare selon la syntaxe suivante : 
\begin{algorithm}[!h]
\centering
\floatname{algorithm}{Sous-routine}
\begin{algorithmic}
\STATE{\textbf{Sub} nomsousroutine([param1,param2,...])}
\STATE{[code de la sous-routine]}
\STATE{\textbf{End Sub} }
\end{algorithmic} 
\caption{\textit{sous routine}}
\label{algo:sous-routine}
\end{algorithm}

\item Les fonctions\\
La déclaration d'une fonction adopte une syntaxe similaire avec le mot clé Function\\
\begin{algorithm}[!h]
\centering
\floatname{algorithm}{Fonction}
\begin{algorithmic}
\STATE{\textbf{Function} nomfonction ([param1,param2,...])[\textbf{As} \textit{type}]}
\STATE{[code de la fonction]}
\STATE{\textbf{End Function} }
\end{algorithmic} 
\caption{\textit{fonction} }
\label{algo:Fonction}
\end{algorithm}

\textbf{As} \textit{type} indique le type de la valeur retournée par la fonction.\\
Notons que \textit{nom-fonction} à l'intérieur du code de la fonction se comporte comme une variable privée. ELle initialisée à zéro à l'appel de la fonction et sa valeur est retournée quand on sort de la fonction.
	
	\item Les commandes
\begin{algorithm}[!h]
\centering
\floatname{algorithm}{Commande}
\begin{algorithmic}
\STATE{\textbf{Command}[CLA][INS]nomcommande([param1,param2,...])}
\STATE{$\{$$[$code de la commande$]$$\}$}
\STATE{\textbf{End Command} }
\end{algorithmic} 
\caption{\textit{commande}}
\label{algo:Commande}
\end{algorithm}

Un tableau ne peut être passé en paramètre d'une commande.\\
La définition d'une commande ne peut se faire que dans le programmme de la carte et non dans celui du terminal.	
L'appel d'une commande s'effectue à l'aide d'un identifiant codé sur 2 octets aussi appelés CLA INS dans la norme ISO/IEC 7816-4.
\lstset{title=VerifPin, caption=Verification Pin}
\begin{lstlisting}
Command BasePIN &H01 VerifPin(PinSaisi as String*4)
   If CarteAnnulee Then
      SW1SW2=swCarteAnnulee
      Exit Command
   End If
   'si code bon
   If PinSaisi=PinCard Then
      CompteurErreur = 0
   'si mauvais code
   Else
      SW1SW2=swPINERROR
      CompteurErreur = CompteurErreur + 1
      If CompteurErreur >= ErreurMax Then
         CarteAnnulee = 1
         SW1SW2=swCarteAnnulee
      End If
   End If
End Command
\end{lstlisting}
	\end{enumerate}

\pagebreak

\textbf{Déclaration d'une procédure \\}
Comme en langage C, une procédure ne peut être appelée que si elle a été définie, sauf si son prototype a été déclarée au préalable comme suit :
\begin{algorithm}[!h]
\centering
\floatname{algorithm}{Procedure}
\begin{algorithmic}
\STATE{\textbf{Declare Command}[CLA][INS]nomcommande([param1,param2,...])}
\STATE{\textbf{Declare Function} nomfonction ([param1,param2,...])[\textbf{As} \textit{type}]}
\STATE{\textbf{Declare Sub} nomsousroutine([param1,param2,...])}
\end{algorithmic} 
\caption{\textit{Déclaration de procédure}}
\label{algo:procedure}
\end{algorithm}


\textbf{Appel d'une procédure \\}
\begin{enumerate}
\item Appel d'une sous-routine
\textbf{Call} nomsousroutine([param1,param2,...])
L'appel doit correspondre exactement au prototype de la sous-routine.

\item Appel d'une fonction
Dans la mesure où une fonction retourne une valeur, elle est directement utilisable dans une expression.

\item Appel d'une commande
Globalement,l'appel d'une commande est similaire à celui d'une fonction dans la mesure où une commande retourne en fait un code d'erreur assimilable à la valeur de retour d'une fonction. Ainsi on écrira pour appeler une commande:\\
variable = nomcommande([param1,param2,...])\\
ou\\
\textbf{Call} nomcommande([param1,param2,...])
\end{enumerate}


\subsection{Implémentation des courbes elliptiques dans les BasicCard}
Le langage ZC-Basic implémente les deux types de courbes elliptiques les plus utilisées en cryptographie, à savoir celles definies sur les corps de Gallois GF(p), où p un nombre premier, et celles définies sur les corps de gallois GF($2^n$) où $n$ est un entier.
La librairie ZC-Basic pour les les premières courbes s'appelle EC-p Library. Pour le deuxième type, il faut utiliser l'une des trois librairies suivante : Library EC-211,Library EC-167 et Library EC-161 (211, 167 et 161 représentent le nombre de bits des clés.)\\

EC-p Library implémente au total 19 courbes elliptiques. Les quatorze premières, numérotées de 1 à 14, suivent les  recommandations du standard ECC Brainpool Standard Curves and Curve Generation v 1.0. Les cinq dernières, numérotées de 15 à 19, se conforment aux recommandations du NIST précisées dans le DSS FIPS PUB 186-3: Digital Signature Standard


\subsubsection{Choix de la courbe elliptique}

\textbf{Générateur G, ordre de G et cofacteur\\}
Dans les recommandations du NIST, une attention particulière est portée au choix de la courbe elliptique, d'un générateur G qui est un point de cette courbe. L' l'ordre de G est noté $n$; c'est un grand nombre premier.

A celui-ci on associe un cofacteur $h$, entier non divisible par $n$, tel que $hn$ représente le nombre de point sur la courbe.Le NIST préconise de choisir le cofacteur aussi petit que possible. En pratique les courbes recommandées ont un cofacteur égal à 1, 2 ou 4 pour des raisons d'efficacité. Cela permet en effet d'avoir des clefs privées et publiques de taille équivalente.\\ 

\textbf{Choix du corps de Gallois \\} 
Dans les recommandations il est possible de choisir entre les corps de Gallois $GF(p)$, avec $p$ premier, et un champ binaire $GF(2^m)$. Notre choix s'est porté sur le premier type de champ pour des raisons de comptabilité entre les librairies cryptographiques java et basicCard. Avec un corps de Gallois $GF(p)$, la sécurité dépend de la longueur en bits de $p$. 
\pagebreak

\textbf{Courbe elliptique \\}
La courbe que nous avons choisi est la courbe P-256. Pour celle-ci, les recommandations du NIST préconisent pour l'implémentation des points suivants :
\begin{itemize}
\item Comme pour les autres courbes sur un corps de Gallois $GF(p)$ l'équation de la courbe elliptique est $y^2=x^3 - 3x + b \mod p$. le cofacteur $h$ vaut $1$.
\item le modulo premier\\
$p = 115792089210356248762697446949407573530086143415290314195533631308867097853951$
\item l'ordre du groupe \\
$n = 115792089210356248762697446949407573529996955224135760342422259061068512044369$
\item la graine pour le générateur aléatoire des coefficients basé sur SHA-1\\
$SEED = c49d3608 86e70493 6a6678e1 139d26b7 819f7e90$
\item la sortie du générateur aléatoire SHA-1\\
$c = 7efba166 2985be94 03cb055c 75d4f7e0 ce8d84a9 c5114abc af317768 0104fa0d$
\item le coefficient\\
$b = 5ac635d8 aa3a93e7 b3ebbd55 769886bc 651d06b0 cc53b0f6 3bce3c3e 27d2604b$.\\
Celui-ci satisfait $b^2c = -27 \mod p$
\item les coordonnées $(G_x,G_y)$ du générateur $G$ valent:\\
- $G_x = 6b17d1f2 e12c4247 f8bce6e5 63a440f2 77037d81 2deb33a0 f4a13945 d898c296$\\
- $G_y = 4fe342e2 fe1a7f9b 8ee7eb4a 7c0f9e16 2bce3357 6b315ece cbb64068 37bf51f5$
\end{itemize}



%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
\subsection{Choix du modèle de carte BasicCard}

\noindent Le choix de la carte à puce à utiliser est important. Chaque carte à puce possède des caractéristiques différentes. Le critère primordiale pour nous est les fonctions cryptographiques disponibles. Nous avions choisis au départ d'utiliser l'algorithme RSA pour signer nos données et puis nous nous sommes aperçus qu'il n'était pas disponible sur les cartes que nous possédions. C'est pourquoi nous avions décidé d'utiliser les courbes elliptiques. Il y avait plusieurs types de courbes elliptiques possibles pour signer avec l'algorithme ECDSA, il nous fallait une courbe elliptique disponible en JAVA et sur la Basic Card et si possible tout en étant conforme aux recommandations de l'ANSSI \cite{anssi}.\\

Après avoir définis ce que nous voulions, il nous restait deux choix et malheureusement le kit qui nous a été fourni ne contenait aucune des deux cartes sélectionnées. Notre choix final s'est porté sur la carte ZC 7.4, bien que l'espace mémoire sur la carte soit assez limité. Ceci s'explique par le fait que nous avons choisi parmi les courbes elliptiques recommandés par l'ANSSI celle avec la plus petite taille de clé et qui soit à la fois compatible avec Basic card et java. De plus, le renouvellement rapide des cartes (deux ans) nous conforte dans le choix d'une clé de taille limitée qui offre une sécurité suffisante pendant la durée de validité.\\

En résumé, nous avons utilisé la carte ZC 7.4 avec l'algorithme ECDSA à l'aide des courbes elliptiques P-256.


%L'agorithme de signature utilisé est ECDSA avec des courbes elliptiques P-256. Nous avons choisi celle-ci car c'est la plus petite taille de clé possible conformément aux recommandations de l'ANSSI.

%Les différentes carte à puces mises à notre disposition ne possédaient pas une version commune avec Java d'algorithme de signature avec les courbes elliptiques. C'est pourquoi nous avons choisi d'émuler une Basic Card ZC7.4 à l'aide du programme fournit par ZeitControl. Les caractéristiques sont : \\

\begin{center}
\begin{tabular}{|c|c|c|c|c|c|c|c|c|c|c|c|c|}
\hline Version & User EEPROM & T=0 & T=1 & T=CL & EAX & OMAC & AES &  DES & RSA & EC & SHA \\

%\hline ZC 4.5A & 30 K & $\checkmark$ & $\checkmark$ & & & & $\checkmark$ & & 1024 & & SHA-1 \\

%\hline ZC 4.5D & 30 K & $\checkmark$ & $\checkmark$ & & & & & $\checkmark$ & 1024 & & SHA-1 \\

%\hline ZC 5.4 & 16 K & $\checkmark$ & $\checkmark$ & & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & & EC-211 & SHA-256 \\
%
%\hline ZC 5.5 & 32 K & $\checkmark$ & $\checkmark$ & & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & & EC-211 & SHA-256 \\
%
%\hline ZC 5.6 & 60.5 K & $\checkmark$ & $\checkmark$ & & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & & EC-211 & SHA-256 \\

\hline ZC 7.4 & 16 K & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & 4096 & EC-p & SHA-256 \\

\hline ZC 7.5 & 32 K & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & $\checkmark$ & 4096 & EC-p & SHA-256 \\

\hline 
\end{tabular}
\end{center}

\subsubsection{Programmation de la BasicCard}
Dans la mesure où la communication est entièrement prise en charge par l'environnement, le programmeur n'a à se soucier que de l'implémentation des commandes que la carte aura à mettre en œuvre ainsi que de l'appel de ces commandes par le terminal.\\





